home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 3 / CD ACTUAL 3.iso / linux / system / flicb_1.6 / flicb_1 / flicb / main.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-11  |  22.5 KB  |  492 lines
  1. /* Fairlight's ICB Client                                                    */
  2. /* Copyright 1994, Mark Luljak <fairlite@arcadia.aldridge.sol.net>           */
  3. /*                                                                           */
  4.  
  5. extern int errno;
  6.  
  7. #include "flicb.h"
  8.  
  9. int main(argc,argv)
  10. int argc;
  11. char *argv[];
  12. {
  13.      int s,a,y,b,c,input_x,error=0;
  14.      char buffer[STRINGSIZE],*mptr,buff2[STRINGSIZE];
  15.      char inbuffer[STRINGSIZE];
  16.      char *ibptr,*cptr;
  17.      int ibflag=1;
  18.      unsigned char in_chr;
  19.      int inresult=0,rex=0;
  20.      char *qptr;
  21.      unsigned char buflen;
  22.      struct passwd *pwptr;
  23.      WINDOW *mainwin, *inputwin,*blankwin;
  24.      char tmpbuf[STRINGSIZE],tmp2buf[STRINGSIZE];
  25.      char nick[12],group[8],*nickptr,*gpptr;
  26.      char trebuf[STRINGSIZE],*treptr;
  27.      unsigned char l;
  28.      fd_set pending;
  29.      struct infoback mninfo;
  30.      struct infoback *mnptr;
  31.      char statline[80];
  32.      time_t *stmptr;
  33.      int totalinchr=0;
  34.      int ox=0,bx=0;
  35.      char *bbuf,*obuf,oldbuf[STRINGSIZE],backbuf[BACK_BUFF_SIZE];
  36.      char rebuf[STRINGSIZE];
  37.      char *reptr,*reoptr;
  38.      int pauseflag=0;
  39.      char pchar;
  40.      int histbit=1,histon=0,histlen=0,hcpy=0;
  41.      char *hist1,histbuf[14],*hisptr;
  42.      char *tnptr,tmpnick[20],tmpgroup[20];
  43.      int tnumber=0;
  44.      struct timeval yoda;
  45.      struct timeval *yodaptr;
  46.  
  47.      if (! argv[1]) {
  48.           printf("Usage: flicb nickname [group]\n");
  49.           exit(1);
  50.      }
  51.      sprintf(tmpnick,"%s",argv[1]);
  52.      sprintf(nick,"");
  53.      tnptr=tmpnick;
  54.      for (tnumber=0;tnumber < 12 && *tnptr;tnumber++) {
  55.           sprintf(nick,"%s%c",nick,*tnptr);
  56.           tnptr++;
  57.      }    
  58.      if (!argv[2]) {                          /* See if there's a group as */
  59.           sprintf(group,"1");                 /* Argument one.  Quit if no */
  60.      } else {
  61.           sprintf(tmpgroup,"%s",argv[2]);
  62.           sprintf(group,"");
  63.           tnptr=tmpgroup;
  64.           for (tnumber=0;tnumber < 8 && *tnptr;tnumber++) {
  65.                sprintf(group,"%s%c",group,*tnptr);
  66.                tnptr++;
  67.           }    
  68.      }
  69.  
  70.      printf("Waiting for server connection...\n");
  71.      nickptr=nick;
  72.      gpptr=group; 
  73.      yodaptr=&yoda;
  74.      yodaptr->tv_sec=60;
  75.      yodaptr->tv_usec=0;
  76.      mnptr=&mninfo;
  77.      mnptr->yres=y;
  78.      mnptr->nickinfo=nick;
  79.      mnptr->groupinfo=group;
  80.      mnptr->dopage=1;
  81.      alertmes=0;
  82.      mnptr->linesup=0;
  83.      mnptr->pageflag=0;
  84.      time((time_t *)&stmptr);
  85.      sprintf(statline,"Nick: %-13s  Group: %-8s  | /h - Help | FLICB %s |  Time: %-6s",mnptr->nickinfo,mnptr->groupinfo,FLICB_VER,ampm(stmptr,0));
  86.      fcntl(fileno(stdin),F_SETFL,O_NDELAY);
  87.  
  88.      pwptr=getpwuid(getuid());
  89.  
  90.      s = connecticb();                        /* Make s a socket to server */
  91.  
  92.      login(s,pwptr->pw_name,nick,group);
  93.      signal(SIGINT,SIG_IGN);
  94.      initscr();
  95.      noecho();
  96.      cbreak();
  97. #ifdef _M_XENIX
  98.      nl();
  99. #endif
  100.      input_x=0;
  101.      y = 0;
  102.      mainwin = newwin(WINSIZE,80,0,0);
  103.      blankwin = newwin(WINSIZE+4,80,0,0);
  104.      flushok(mainwin,TRUE);
  105.      scrollok(mainwin,TRUE);
  106.      leaveok(mainwin,TRUE);
  107.      inputwin = newwin(4,80,20,0);
  108.      flushok(inputwin,TRUE);
  109.      scrollok(inputwin,FALSE);
  110.      flushok(blankwin,TRUE);
  111.      scrollok(blankwin,FALSE);
  112.      savetty();
  113.      hioutput(statline,0,0,inputwin);
  114.      wclear(mainwin);
  115.      wrefresh(mainwin); 
  116.      for (;;) {
  117.           resetty();
  118.           yodaptr->tv_sec=60;
  119.           yodaptr->tv_usec=0;
  120.           time((time_t *)&stmptr);
  121.           sprintf(statline,"Nick: %-13s  Group: %-8s  | /h - Help | FLICB %s |  Time: %-6s",mnptr->nickinfo,mnptr->groupinfo,FLICB_VER,ampm(stmptr,0));
  122.           wrefresh(mainwin);
  123.           hioutput(statline,0,0,inputwin);
  124.           wmove(inputwin,2,input_x);
  125.           wrefresh(inputwin);
  126.           FD_ZERO(&pending);
  127.           FD_SET(fileno(stdin), &pending);
  128.           FD_SET(s, &pending);
  129.           if (select(s + 1, &pending, NULL, NULL, yodaptr) < 0) {
  130.                perror("mainloop: select");
  131.           }
  132.           if (FD_ISSET(s, &pending)) {
  133.                a=read(s,&buflen,sizeof(unsigned char));
  134.                if (a>0) {
  135.                     c=(int)buflen;
  136.                     b=read(s,buffer,c*sizeof(char));
  137.                     for (;b<c;) {
  138.                          if (b != -1) {
  139.                               c-=b;
  140.                          }
  141.                          b=read(s,buff2,c*sizeof(char));
  142.                          sprintf(buffer,"%s%s",buffer,buff2);
  143.                          for (qptr=buff2;*qptr;qptr++) {
  144.                               *qptr='\0';
  145.                          }
  146.                          if (b != -1) {
  147.                               c-=b;
  148.                          }
  149.                     }
  150.                     mnptr=(struct infoback *)in_packet_handle(s,buffer,y,mainwin,inputwin,nickptr,gpptr,mnptr->dopage,mnptr->pageflag); 
  151.                     y+=mnptr->yres;
  152.                     nickptr=mnptr->nickinfo;
  153.                     gpptr=mnptr->groupinfo;
  154.                     time((time_t *)&stmptr);
  155.                     sprintf(statline,"Nick: %-13s  Group: %-8s  | /h - Help | FLICB %s |  Time: %-6s",mnptr->nickinfo,mnptr->groupinfo,FLICB_VER,ampm(stmptr,0));
  156.                     hioutput(statline,0,0,inputwin);
  157.                     wrefresh(inputwin);
  158.                     for (qptr=buffer;*qptr;qptr++) {
  159.                          *qptr='\0';
  160.                     }
  161.                }      
  162.           }
  163.  
  164.           wmove(inputwin,2,input_x);
  165.           wrefresh(inputwin);
  166.           if (FD_ISSET(fileno(stdin), &pending)) {
  167.                wmove(inputwin,2,input_x);
  168.                wrefresh(inputwin);
  169.                if (ibflag) {
  170.                     ibflag=0;
  171.                     ibptr=inbuffer;
  172.                }
  173.                inresult=read(fileno(stdin),&in_chr,sizeof(unsigned char));
  174.                if (inresult>0) {
  175.                     if (in_chr == '\n') {
  176.                          *ibptr='\0';
  177.                          ibptr++;
  178.                          for (qptr=ibptr;*qptr;qptr++) {
  179.                               *qptr='\0';
  180.                          }
  181.                          input_x=0;
  182.                          histbit=1;
  183.                          histon=0;
  184.                          totalinchr=0;
  185.                          wmove(inputwin,2,input_x);
  186.                          if (strlen(inbuffer) != 0) {
  187.                               cptr=inbuffer;
  188.                               if (*cptr == '/') {
  189.                                    cptr++;
  190.                                    #ifdef SYSLOG
  191.                                    openlog("flicb",LOG_PID,LOG_USER);
  192.                                    syslog(LOG_INFO,"cptr= %s",cptr);
  193.                                    #endif  
  194.                                    mnptr=(struct infoback *)out_packet_handle(s,cptr,y,mainwin,0,inputwin,nickptr,gpptr,mnptr->dopage,mnptr->pageflag,mnptr->linesup);
  195.                                    if (mnptr->yres != 9999) {
  196.                                         y+=mnptr->yres;
  197.                                    } else {y=0;}
  198.                                    nickptr=mnptr->nickinfo;
  199.                                    gpptr=mnptr->groupinfo;
  200.                                    time((time_t *)&stmptr);
  201.                                    sprintf(statline,"Nick: %-13s  Group: %-8s  | /h - Help | FLICB %s |  Time: %-6s",mnptr->nickinfo,mnptr->groupinfo,FLICB_VER,ampm(stmptr,0));
  202.                                    hioutput(statline,0,0,inputwin);
  203.                                    wrefresh(inputwin);
  204.                               } else {
  205.                                    mnptr=(struct infoback *)out_packet_handle(s,cptr,y,mainwin,1,inputwin,nickptr,gpptr,mnptr->dopage,mnptr->pageflag,mnptr->linesup);
  206.                                    if (mnptr->yres != 9999) {
  207.                                         y+=mnptr->yres;
  208.                                    } else {y=0;}
  209.                                    time((time_t *)&stmptr);
  210.                                    sprintf(statline,"Nick: %-13s  Group: %-8s  | /h - Help | FLICB %s |  Time: %-6s",mnptr->nickinfo,mnptr->groupinfo,FLICB_VER,ampm(stmptr,0));
  211.                                    hioutput(statline,0,0,inputwin);
  212.                                    wrefresh(inputwin);
  213.                               }
  214.                          }
  215.                          for (qptr=inbuffer;*qptr;qptr++) {
  216.                               *qptr='\0';
  217.                          }
  218.                          for (qptr=histbuf;*qptr;qptr++) {
  219.                               *qptr='\0';
  220.                          }
  221.                          ibflag=1;
  222.                          wmove(inputwin,2,input_x);
  223.                          wclrtoeol(inputwin);
  224.                          wmove(inputwin,2,input_x);
  225.                          wrefresh(inputwin);
  226.                     } else {
  227.                          if (CTRLCHECK('H') == in_chr || in_chr == DELETE
  228.                  || CTRLCHECK('L') == in_chr
  229.                              || CTRLCHECK('A') == in_chr
  230.                              || CTRLCHECK('N') == in_chr
  231.                              || CTRLCHECK('W') == in_chr
  232.                              || CTRLCHECK('P') == in_chr 
  233.                              || CTRLCHECK('X') == in_chr
  234.                              || CTRLCHECK('I') == in_chr) {
  235.                               if (CTRLCHECK('P') == in_chr) {
  236.                                         wmove(inputwin,0,0);
  237.                                         wclrtoeol(inputwin);
  238.                                         center("                         -< PRESS ANY KEY TO RESUME >-                          ",0,inputwin,1);
  239.                                         wrefresh(inputwin);
  240.                                    for (pauseflag=0;!pauseflag;) {
  241.                                         FD_ZERO(&pending);
  242.                                         FD_SET(fileno(stdin), &pending);
  243.                                         if (select(s + 1, &pending, NULL, NULL, NULL) < 0) {
  244.                                               perror("mainloop: select");
  245.                                         }
  246.                                         if (FD_ISSET(fileno(stdin), &pending)) {
  247.                                              read(fileno(stdin),&pchar,1*sizeof(char));
  248.                                              pauseflag=1;
  249.                                         }
  250.                                    }
  251.                                         time((time_t *)&stmptr);
  252.                                         sprintf(statline,"Nick: %-13s  Group: %-8s  | /h - Help | FLICB %s |  Time: %-6s",mnptr->nickinfo,mnptr->groupinfo,FLICB_VER,ampm(stmptr,0));
  253.                                         hioutput(statline,0,0,inputwin);
  254.                                         wrefresh(inputwin);
  255.                               }
  256.                               if (CTRLCHECK('N') == in_chr) {
  257.                                    if (mnptr->dopage==0) {
  258.                                         mnptr->dopage=1;
  259.                                         center("Auto-Hold:  On",3,inputwin,1);
  260.                                    } else {
  261.                                         center("Auto-Hold:  Off",3,inputwin,1);
  262.                                         mnptr->dopage=0;
  263.                                    }
  264.                                    wrefresh(inputwin);
  265.                                    sleep(2);
  266.                                    wmove(inputwin,3,0);
  267.                                    wclrtoeol(inputwin);
  268.                                    wmove(inputwin,2,input_x);
  269.                                    wrefresh(inputwin);
  270.                                    resetty();
  271.                               }
  272.  
  273.                               if (CTRLCHECK('A') == in_chr) {
  274.                                    if (alertmes==0) {
  275.                                         alertmes=1;
  276.                                         center("Message Alert:  On",3,inputwin,1);
  277.                                    } else {
  278.                                         center("Message Alert:  Off",3,inputwin,1);
  279.                                         alertmes=0;
  280.                                    }
  281.                                    wrefresh(inputwin);
  282.                                    sleep(2);
  283.                                    wmove(inputwin,3,0);
  284.                                    wclrtoeol(inputwin);
  285.                                    wmove(inputwin,2,input_x);
  286.                                    wrefresh(inputwin);
  287.                                    resetty();
  288.                               }
  289.  
  290.                   if (CTRLCHECK('L') == in_chr) {
  291.                                    touchwin(blankwin);
  292.                    wrefresh(blankwin);
  293.                                    resetty();
  294.                                    touchwin(mainwin);
  295.                    wrefresh(mainwin);
  296.                                    resetty();
  297.                                    wmove(inputwin,2,input_x);
  298.                                    touchwin(inputwin);
  299.                    wrefresh(inputwin); 
  300.                                    resetty();
  301.                   }
  302.                               if ((CTRLCHECK('W') == in_chr)) {
  303.                               while (in_chr && input_x > 0 && in_chr != ' ') {
  304.                                    input_x--;
  305.                                    ibptr--;
  306.                                    totalinchr--;
  307.                                    if ((totalinchr > BACK_BUFF_SIZE) && (input_x  < BACK_BUFF_SIZE)) {
  308.                                         wmove(inputwin,2,0);
  309.                                         wclrtoeol(inputwin);
  310.                                         input_x=IN_SEGMENT_SIZE-3;
  311.                                         reptr=rebuf;
  312.                                         reoptr=ibptr;
  313.                                         for (rex=IN_SEGMENT_SIZE-3;rex>0;rex--) {
  314.                                              reoptr--;
  315.                                         }
  316.                                         for (rex=IN_SEGMENT_SIZE-2;rex>0;rex--) {
  317.                                              *reptr=*reoptr;
  318.                                              reptr++;
  319.                                              reoptr++;
  320.                                         }
  321.                                         output(rebuf,2,0,inputwin);
  322.                                    }
  323.                                    wmove(inputwin,2,input_x);
  324.                                    waddch(inputwin,' ');
  325.                                    wrefresh(inputwin);
  326.                                    if( input_x >= 1 ) {
  327.                                         in_chr = *(ibptr-1);
  328.                                    } else {
  329.                                         in_chr = *ibptr;
  330.                                    }
  331.                               }}
  332.  
  333.                               if (CTRLCHECK('X') == in_chr) {
  334.                                    for (qptr=inbuffer;*qptr;qptr++) {
  335.                                         *qptr='\0';
  336.                                    }
  337.                                    ibptr=inbuffer;
  338.                                    input_x=0;
  339.                                    totalinchr=0;
  340.                                    histbit=1;
  341.                                    histon=0;
  342.                                    wmove(inputwin,2,input_x);
  343.                                    wclrtoeol(inputwin);
  344.                                    wmove(inputwin,2,input_x); 
  345.                                    wrefresh(inputwin);
  346.                               }
  347.                               if (CTRLCHECK('I') == in_chr && histbit==1) {
  348.                                    if (histcount()) {
  349.                                    if (histon==1) {
  350.                                         totalinchr=0;
  351.                                         input_x=0;
  352.                                         wmove(inputwin,2,0);  
  353.                                         wclrtoeol(inputwin);
  354.                                         wrefresh(inputwin);
  355.                                    } else {
  356.                                         histon=1;
  357.                                    }
  358.                                    ibflag=0;
  359.                                    for (qptr=inbuffer;*qptr;qptr++) {
  360.                                         *qptr='\0';
  361.                                    }
  362.                                    for (qptr=histbuf;*qptr;qptr++) {
  363.                                         *qptr='\0';
  364.                                    }
  365.                                    hist1=(char *)histget();
  366.                                    sprintf(histbuf,"/m %s ",hist1);
  367.                                    histlen=strlen(histbuf);
  368.                                    ibptr=inbuffer;
  369.                                    hisptr=histbuf;
  370.                                    for (hcpy=0;hcpy<histlen-1;hcpy++) {
  371.                                         *ibptr=*hisptr;
  372.                                         ibptr++;
  373.                                         hisptr++;
  374.                                    }
  375.                                    *ibptr=' ';
  376.                                    ibptr++;
  377.                                    for (qptr=ibptr;*qptr;qptr++) {
  378.                                         *qptr='\0';
  379.                                    }
  380.                                    #ifdef SYSLOG
  381.                                    openlog("flicb",LOG_PID,LOG_USER);
  382.                                    syslog(LOG_INFO,"tabhist histbuf %s",histbuf);
  383.                                    syslog(LOG_INFO,"tabhist inbuf %s",inbuffer);
  384.                                    closelog();
  385.                                    #endif 
  386.                                    output(histbuf,2,0,inputwin);
  387.                                    totalinchr+=histlen;
  388.                    input_x+=histlen;
  389.                                    wmove(inputwin,2,input_x);
  390.                                    wrefresh(inputwin);
  391.                                    for (qptr=histbuf;*qptr;qptr++) {
  392.                                         *qptr='\0';
  393.                                    }
  394.                               }}
  395.                   if ((CTRLCHECK('H') == in_chr) || (in_chr 
  396.                                    == DELETE)) {
  397.                               if (in_chr && input_x > 0) {
  398.                                    input_x--;
  399.                                    if (input_x == 0) {
  400.                                         histbit=1;
  401.                                    }
  402.                                    ibptr--;
  403.                                    totalinchr--;
  404.                                    if ((totalinchr > BACK_BUFF_SIZE) && (input_x < BACK_BUFF_SIZE)) {
  405.                                         wmove(inputwin,2,0);
  406.                                         wclrtoeol(inputwin);
  407.                                         input_x=IN_SEGMENT_SIZE-3;
  408.                                         treptr=trebuf;
  409.                                         reoptr=ibptr;
  410.                                         for (rex=IN_SEGMENT_SIZE-3;rex>0;rex--) {
  411.                                              reoptr--;
  412.                                         }     
  413.                                         for (rex=IN_SEGMENT_SIZE-2;rex>0;rex--) {
  414.                                              *treptr=*reoptr;
  415.                                              treptr++;
  416.                                              reoptr++;
  417.                                         }
  418.                                         output(trebuf,2,0,inputwin);
  419.                                    }
  420.                                    wmove(inputwin,2,input_x);
  421.                                    waddch(inputwin,' ');
  422.                                    wrefresh(inputwin);
  423.                               } else {
  424.                                    input_x=0;
  425.                                    totalinchr=0;
  426.                                    histbit=1;
  427.                                    histon=0;
  428.                                    wmove(inputwin,2,input_x);
  429.                                    wrefresh(inputwin);
  430.                               }}
  431.                          } else {
  432.                               histbit=0;
  433.                               if (totalinchr == MAXMSGSTRLEN) {
  434.                                    wmove(inputwin,2,79);
  435.                                    waddch(inputwin,'\007');
  436.                                    wrefresh(inputwin);
  437.                                    wmove(inputwin,2,79);
  438.                                    waddch(inputwin,' ');
  439.                                    wmove(inputwin,2,input_x);
  440.                                    wrefresh(inputwin);
  441.                               } else {
  442.                               totalinchr++;
  443.                               if (input_x == IN_SEGMENT_SIZE-2) {
  444.                                    input_x=0;
  445.                                    wmove(inputwin,2,input_x);
  446.                                    wclrtoeol(inputwin);
  447.                                    wmove(inputwin,2,input_x);
  448.                                    wrefresh(inputwin);
  449.                                    bbuf=backbuf;
  450.                                    obuf=ibptr;
  451.                                    for (ox=BACK_BUFF_SIZE;ox>0;ox--) {
  452.                                         obuf--;
  453.                                    }
  454.                                    for (bx=BACK_BUFF_SIZE;bx>0;bx--) {
  455.                                         *bbuf=*obuf;
  456.                                         bbuf++;
  457.                                         obuf++;
  458.                                    }
  459.                                    bbuf=backbuf;
  460.                                    output(bbuf,2,input_x,inputwin);
  461.                                    input_x+=BACK_BUFF_SIZE;
  462.                                    wmove(inputwin,2,input_x);
  463.                                    wrefresh(inputwin);
  464.                               #ifdef SYSLOG
  465.                               openlog("flicb",LOG_PID,LOG_USER);
  466.                               syslog(LOG_INFO,"got to next region: letter= %c",in_chr);
  467.                               closelog();
  468.                               #endif
  469.  
  470.                               }
  471.                               wmove(inputwin,2,input_x);
  472.                               waddch(inputwin,in_chr);
  473.                               input_x++;
  474.                               wmove(inputwin,2,input_x);
  475.                               wrefresh(inputwin);
  476.                               *ibptr=in_chr;
  477.                               #ifdef SYSLOG
  478.                               openlog("flicb",LOG_PID,LOG_USER);
  479.                               syslog(LOG_INFO,"chr= %c inbuffer= %s",in_chr,inbuffer);
  480.                               closelog();
  481.                               #endif
  482.                               ibptr++;
  483.                               inresult=0;
  484.                               }
  485.                          }
  486.                     }
  487.                }
  488.           }
  489.      }                                    
  490.      exit(0);                            
  491. }
  492.